{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第8章 DQN改进算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import gymnasium as gym\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import rl_utils\n",
    "from tqdm import tqdm\n",
    "import cv2\n",
    "import imageio\n",
    "\n",
    "## 构造智能体agent的大脑，也就是输入状态，返回该状态下，每个动作的动作价值\n",
    "## 输入是状态的，也就是 (车子center-point的坐标，车子的速度，杆的竖直角度，杆的角速度)\n",
    "## 返回值应该是2 dim，\n",
    "class Qnet(torch.nn.Module):\n",
    "    ''' 只有一层隐藏层的Q网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(Qnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)  ## full connect层1\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim) ## full connect层2\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))  # 隐藏层使用ReLU激活函数\n",
    "        return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "##  构造智能体的\n",
    "class DQN:\n",
    "    ''' DQN算法 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,\n",
    "                 epsilon, target_update, device, dqn_type='VanillaDQN'):\n",
    "        self.action_dim = action_dim  ##  动作的dim\n",
    "        ## 实例化智能体的大脑\n",
    "        self.q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)  # Q网络\n",
    "        # 目标网络\n",
    "        self.target_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "        # 使用Adam优化器\n",
    "        self.optimizer = torch.optim.Adam(self.q_net.parameters(), lr=learning_rate)\n",
    "        self.gamma = gamma  # 折扣因子\n",
    "        self.epsilon = epsilon  # epsilon-贪婪策略\n",
    "        self.target_update = target_update  # 目标网络更新频率\n",
    "        self.count = 0  # 计数器,记录更新次数\n",
    "        self.dqn_type = dqn_type\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):  # epsilon-贪婪策略采取动作\n",
    "        # if np.random.random() < self.epsilon * np.exp(-self.count/100):\n",
    "        if np.random.random() < self.epsilon:\n",
    "            action = np.random.randint(self.action_dim) ## 随机选择一个动作\n",
    "        else:\n",
    "            state = torch.tensor([state], dtype=torch.float).to(self.device) ## 状态\n",
    "            action = self.q_net(state).argmax().item()  ## 智能体的大脑，根据状态拿到动作价值，q_net返回值是每个动作的动作价值，然后拿到动作的\n",
    "        return action\n",
    "\n",
    "    ## 拿到一个状态对应的所有动作的动作价值，并返回动作价值的最大值\n",
    "    def max_q_value(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        return self.q_net(state).max().item()\n",
    "\n",
    "    ## 使用历史数据来训练智能体的大脑，两个大脑的，一个实时update做label，另一个延迟update做predict\n",
    "    '''\n",
    "    损失函数需要label和predict，但是强化学习是没有label的，所以需要人工构造label才行，DQN使用的构造方式是使用update步长不相同的两个Qnet，\n",
    "    update数量较多的Qnet来做label，数量较少的Qnet来做predict。所以label就是使用的newest update的Qnet。相当是两个人，一个学的时间长些，\n",
    "    一个学的时间短些，所以这个学习时间更长的人，可以当老师了，学习时间短的人，就只能当学生了。老师可以教导学生的。所以两个大脑模型Qnet，\n",
    "    一个做老师，一个是学生，也就是一个label另一个则是predict。这样就构造出了相应的label。\n",
    "    target_q_net使用下一个状态，然后Q-learning来predict当前(状态，动作)的动作价值，predict\n",
    "    q_net使用当前状态和动作，直接算出当前(状态，动作)的动作价值，label\n",
    "    '''\n",
    "    def update(self, transition_dict):\n",
    "        ## 初始化 状态、动作、奖励、下一个状态、是否结束的\n",
    "        states = torch.tensor(transition_dict['states'],\n",
    "                              dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(\n",
    "            self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'],\n",
    "                                   dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'],\n",
    "                             dtype=torch.float).view(-1, 1).to(self.device)\n",
    "\n",
    "        ## target, 因该网络实时update，所以可以看作是真实值，也就是监督学习内的label，而目标网络延迟很多，目标网络的输出可以看作predict\n",
    "        ## “真实”label，q_net输入当前的状态，返回值是当前状态下每个动作的动作价值，所以gather以后拿到的是：当前(状态和动作)对应的动作价值\n",
    "        q_values = self.q_net(states).gather(1, actions)  # Q值\n",
    "        # 下个状态的最大Q值\n",
    "        if self.dqn_type == 'DoubleDQN': # DQN与Double DQN的区别\n",
    "            max_action = self.q_net(next_states).max(1)[1].view(-1, 1)    ## 统一动作网络，由q_net网络来给出下个状态的动作，标准是最大值\n",
    "            max_next_q_values = self.target_q_net(next_states).gather(1, max_action)    ## target_q_net网络给出动作价值，并通过动作选择动作价值\n",
    "        else: # DQN的情况\n",
    "            ## target_q_net网络给出动作价值，并直接挑选某个状态动作内的最大值，和q_net的动作可能不相同\n",
    "            max_next_q_values = self.target_q_net(next_states).max(1)[0].view(-1, 1)\n",
    "        ## Q-learning algorithm，算出的是当前(状态和动作)的动作价值\n",
    "        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)  # TD误差目标\n",
    "        ## q_net的truth label 和 target_q_net的predict，算损失用来反向传播\n",
    "        ## 也就是两个网络算出来的（状态和动作）对应的动作价值，用MSE来算损失函数的呢\n",
    "        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))  # 均方误差损失函数\n",
    "        self.optimizer.zero_grad()  # PyTorch中默认梯度会累积,这里需要显式将梯度置为0\n",
    "        dqn_loss.backward()   ##  反向传播求出梯度\n",
    "        self.optimizer.step() ##  使用累加的梯度来update参数\n",
    "\n",
    "        if self.count % self.target_update == 0:\n",
    "            self.target_q_net.load_state_dict(\n",
    "                self.q_net.state_dict())  # 更新目标网络\n",
    "        self.count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 1e-2\n",
    "num_episodes = 200\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "epsilon = 0.01\n",
    "target_update = 50\n",
    "buffer_size = 5000\n",
    "minimal_size = 1000\n",
    "batch_size = 64\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "\n",
    "env_name = 'Pendulum-v1'\n",
    "env = gym.make(env_name, render_mode=\"rgb_array\")\n",
    "_ = env.reset(seed=0)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = 11  # 将连续动作分成11个离散动作\n",
    "\n",
    "\n",
    "def dis_to_con(discrete_action, env, action_dim):  # 离散动作转回连续的函数\n",
    "    action_lowbound = env.action_space.low[0]  # 连续动作的最小值\n",
    "    action_upbound = env.action_space.high[0]  # 连续动作的最大值\n",
    "    return action_lowbound + (discrete_action /(action_dim - 1)) * (action_upbound - action_lowbound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_DQN(agent, env, num_episodes, replay_buffer, minimal_size,\n",
    "              batch_size):\n",
    "    return_list = []\n",
    "    max_q_value_list = []\n",
    "    max_q_value = 0\n",
    "    allimage = []\n",
    "    for i in range(10):\n",
    "        with tqdm(total=int(num_episodes / 10),\n",
    "                  desc='Iteration %d' % i) as pbar:\n",
    "            for i_episode in range(int(num_episodes / 10)):\n",
    "                episode_return = 0   ## 累积的奖励\n",
    "                state = env.reset()  ## 环境随机重置的\n",
    "                if len(state)!=3:\n",
    "                    state = state[0]\n",
    "                done = False\n",
    "                # https://huggingface.co/learn/deep-rl-course/unit4/hands-on#create-a-virtual-display\n",
    "                while not done:\n",
    "                    if (i_episode + 1) % 10 == 0 and i in [9]:\n",
    "                        img = env.render()\n",
    "                        allimage.append(img)\n",
    "                    # cv2.imshow(\"CartPole-v1\", img)\n",
    "                    # cv2.waitKey(-1)\n",
    "                    action = agent.take_action(state) ## 拿到动作价值最大的动作，取值可选值是11个\n",
    "                    max_q_value = agent.max_q_value(state) * 0.005 + max_q_value * 0.995  # 平滑处理\n",
    "                    max_q_value_list.append(max_q_value)  # 保存每个状态的最大Q值\n",
    "                    action_continuous = dis_to_con(action, env, agent.action_dim)   ## 离散值到continuous的值\n",
    "                    # next_state, reward, done, _ = env.step([action_continuous])\n",
    "                    ## 环境根据动作，前进一步的，拿到下一个状态，奖励，是否终止，是否步长太长，info\n",
    "                    next_state, reward, terminated, truncated, info = env.step([action_continuous])  \n",
    "                    done = terminated | truncated  ## 终止或者步长太长，都会导致已经结束\n",
    "                    ## 将状态、动作、奖励、下一个状态、是否结束，加入到缓冲池，也就是历史内，用来训练大脑网络的\n",
    "                    replay_buffer.add(state, action, reward, next_state, done)\n",
    "                    state = next_state   ## 下一个状态赋值到当前状态\n",
    "                    episode_return += reward  ##累加奖励的\n",
    "                    if replay_buffer.size() > minimal_size:\n",
    "                        b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(\n",
    "                            batch_size)\n",
    "                        transition_dict = {\n",
    "                            'states': b_s,\n",
    "                            'actions': b_a,\n",
    "                            'next_states': b_ns,\n",
    "                            'rewards': b_r,\n",
    "                            'dones': b_d\n",
    "                        }\n",
    "                        agent.update(transition_dict)\n",
    "                return_list.append(episode_return)\n",
    "                if (i_episode + 1) % 10 == 0:\n",
    "                    pbar.set_postfix({\n",
    "                        'episode':\n",
    "                        '%d' % (num_episodes / 10 * i + i_episode + 1),\n",
    "                        'return':\n",
    "                        '%.3f' % np.mean(return_list[-10:])\n",
    "                    })\n",
    "                pbar.update(1)\n",
    "    return return_list, max_q_value_list, allimage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|██████████| 20/20 [00:07<00:00,  2.57it/s, episode=20, return=-805.985] \n",
      "Iteration 1: 100%|██████████| 20/20 [00:09<00:00,  2.14it/s, episode=40, return=-384.858]\n",
      "Iteration 2: 100%|██████████| 20/20 [00:09<00:00,  2.01it/s, episode=60, return=-227.176]\n",
      "Iteration 3: 100%|██████████| 20/20 [00:09<00:00,  2.21it/s, episode=80, return=-265.117]\n",
      "Iteration 4: 100%|██████████| 20/20 [00:09<00:00,  2.22it/s, episode=100, return=-396.673]\n",
      "Iteration 5: 100%|██████████| 20/20 [00:08<00:00,  2.24it/s, episode=120, return=-249.009]\n",
      "Iteration 6: 100%|██████████| 20/20 [00:09<00:00,  2.19it/s, episode=140, return=-191.522]\n",
      "Iteration 7: 100%|██████████| 20/20 [00:08<00:00,  2.31it/s, episode=160, return=-295.722]\n",
      "Iteration 8: 100%|██████████| 20/20 [00:08<00:00,  2.24it/s, episode=180, return=-226.699]\n",
      "Iteration 9: 100%|██████████| 20/20 [00:11<00:00,  1.72it/s, episode=200, return=-213.604]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "# _ = env.reset(seed=0)\n",
    "torch.manual_seed(0)\n",
    "replay_buffer = rl_utils.ReplayBuffer(buffer_size) ## 实例化缓冲池也就是历史数据\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,\n",
    "            target_update, device)\n",
    "return_list, max_q_value_list, allimage = train_DQN(agent, env, num_episodes,\n",
    "                                          replay_buffer, minimal_size,\n",
    "                                          batch_size)\n",
    "\n",
    "# https://github.com/guicalare/Img2gif/blob/master/Code/Img2Gif.py\n",
    "imageio.mimsave(r'C:\\Users\\10696\\Desktop\\access\\Hands-on-RL\\chapter8_0.gif', allimage, duration=10)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "mv_return = rl_utils.moving_average(return_list, 5)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('DQN on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "frames_list = list(range(len(max_q_value_list)))\n",
    "plt.plot(frames_list, max_q_value_list)\n",
    "plt.axhline(0, c='orange', ls='--')\n",
    "plt.axhline(10, c='red', ls='--')\n",
    "plt.xlabel('Frames')\n",
    "plt.ylabel('Q value')\n",
    "plt.title('DQN on {}'.format(env_name))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|██████████| 20/20 [00:08<00:00,  2.45it/s, episode=20, return=-1070.133]\n",
      "Iteration 1: 100%|██████████| 20/20 [00:11<00:00,  1.68it/s, episode=40, return=-480.449]\n",
      "Iteration 2: 100%|██████████| 20/20 [00:11<00:00,  1.68it/s, episode=60, return=-338.463]\n",
      "Iteration 3: 100%|██████████| 20/20 [00:12<00:00,  1.60it/s, episode=80, return=-228.137]\n",
      "Iteration 4: 100%|██████████| 20/20 [00:12<00:00,  1.62it/s, episode=100, return=-254.474]\n",
      "Iteration 5: 100%|██████████| 20/20 [00:13<00:00,  1.51it/s, episode=120, return=-505.550]\n",
      "Iteration 6: 100%|██████████| 20/20 [00:16<00:00,  1.24it/s, episode=140, return=-325.229]\n",
      "Iteration 7: 100%|██████████| 20/20 [00:12<00:00,  1.56it/s, episode=160, return=-236.748]\n",
      "Iteration 8: 100%|██████████| 20/20 [00:12<00:00,  1.65it/s, episode=180, return=-316.959]\n",
      "Iteration 9: 100%|██████████| 20/20 [00:16<00:00,  1.21it/s, episode=200, return=-172.830]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "# _ = env.reset(seed=0)\n",
    "torch.manual_seed(0)\n",
    "replay_buffer = rl_utils.ReplayBuffer(buffer_size) ## 实例化缓冲池也就是历史数据\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,\n",
    "            target_update, device, 'DoubleDQN')\n",
    "return_list, max_q_value_list, allimage = train_DQN(agent, env, num_episodes,\n",
    "                                          replay_buffer, minimal_size,\n",
    "                                          batch_size)\n",
    "\n",
    "# https://github.com/guicalare/Img2gif/blob/master/Code/Img2Gif.py\n",
    "imageio.mimsave(r'C:\\Users\\10696\\Desktop\\access\\Hands-on-RL\\chapter8_1.gif', allimage, duration=10)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "mv_return = rl_utils.moving_average(return_list, 5)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('Double DQN on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "frames_list = list(range(len(max_q_value_list)))\n",
    "plt.plot(frames_list, max_q_value_list)\n",
    "plt.axhline(0, c='orange', ls='--')\n",
    "plt.axhline(10, c='red', ls='--')\n",
    "plt.xlabel('Frames')\n",
    "plt.ylabel('Q value')\n",
    "plt.title('Double DQN on {}'.format(env_name))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|          | 0/20 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|██████████| 20/20 [00:11<00:00,  1.71it/s, episode=20, return=-993.090] \n",
      "Iteration 1: 100%|██████████| 20/20 [00:14<00:00,  1.35it/s, episode=40, return=-235.237]\n",
      "Iteration 2: 100%|██████████| 20/20 [00:14<00:00,  1.34it/s, episode=60, return=-276.046]\n",
      "Iteration 3: 100%|██████████| 20/20 [00:14<00:00,  1.38it/s, episode=80, return=-251.143]\n",
      "Iteration 4: 100%|██████████| 20/20 [00:14<00:00,  1.40it/s, episode=100, return=-238.741]\n",
      "Iteration 5: 100%|██████████| 20/20 [00:14<00:00,  1.40it/s, episode=120, return=-187.510]\n",
      "Iteration 6: 100%|██████████| 20/20 [00:14<00:00,  1.39it/s, episode=140, return=-262.245]\n",
      "Iteration 7: 100%|██████████| 20/20 [00:15<00:00,  1.32it/s, episode=160, return=-161.531]\n",
      "Iteration 8: 100%|██████████| 20/20 [00:15<00:00,  1.33it/s, episode=180, return=-285.164]\n",
      "Iteration 9: 100%|██████████| 20/20 [00:17<00:00,  1.13it/s, episode=200, return=-169.990]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class VAnet(torch.nn.Module):\n",
    "    ''' 只有一层隐藏层的A网络和V网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(VAnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)  # 共享网络部分\n",
    "        self.fc_A = torch.nn.Linear(hidden_dim, action_dim) ## 优势函数的\n",
    "        self.fc_V = torch.nn.Linear(hidden_dim, 1) ## 状态价值函数的\n",
    "\n",
    "    def forward(self, x):\n",
    "        A = self.fc_A(F.relu(self.fc1(x)))\n",
    "        V = self.fc_V(F.relu(self.fc1(x)))\n",
    "        ## 残差网络的resnet，可以减去A内的均值，也可以不减的\n",
    "        Q = V + A - A.mean(1).view(-1, 1)  # Q值由V值和A值计算得到\n",
    "        return Q\n",
    "\n",
    "\n",
    "class DQN:\n",
    "    ''' DQN算法,包括Double DQN和Dueling DQN '''\n",
    "    def __init__(self,\n",
    "                 state_dim,\n",
    "                 hidden_dim,\n",
    "                 action_dim,\n",
    "                 learning_rate,\n",
    "                 gamma,\n",
    "                 epsilon,\n",
    "                 target_update,\n",
    "                 device,\n",
    "                 dqn_type='VanillaDQN'):\n",
    "        self.action_dim = action_dim  ##  动作的dim\n",
    "        if dqn_type == 'DuelingDQN':  # Dueling DQN采取不一样的网络框架\n",
    "            ## 实例化智能体的大脑\n",
    "            self.q_net = VAnet(state_dim, hidden_dim,\n",
    "                               self.action_dim).to(device)\n",
    "            self.target_q_net = VAnet(state_dim, hidden_dim,\n",
    "                                      self.action_dim).to(device)\n",
    "        else:\n",
    "            ## 实例化智能体的大脑\n",
    "            self.q_net = Qnet(state_dim, hidden_dim,\n",
    "                              self.action_dim).to(device)\n",
    "            self.target_q_net = Qnet(state_dim, hidden_dim,\n",
    "                                     self.action_dim).to(device)\n",
    "        self.optimizer = torch.optim.Adam(self.q_net.parameters(),\n",
    "                                          lr=learning_rate)\n",
    "        self.gamma = gamma  # 折扣因子\n",
    "        self.epsilon = epsilon  # epsilon-贪婪策略\n",
    "        self.target_update = target_update  # 目标网络更新频率\n",
    "        self.count = 0  # 计数器,记录更新次数\n",
    "        self.dqn_type = dqn_type\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):  # epsilon-贪婪策略采取动作\n",
    "        # if np.random.random() < self.epsilon * np.exp(-self.count/100):\n",
    "        if np.random.random() < self.epsilon:\n",
    "            action = np.random.randint(self.action_dim) ## 随机选择一个动作\n",
    "        else:\n",
    "            state = torch.tensor([state], dtype=torch.float).to(self.device) ## 状态\n",
    "            action = self.q_net(state).argmax().item()  ## 智能体的大脑，根据状态拿到动作价值，q_net返回值是每个动作的动作价值，然后拿到动作的\n",
    "        return action\n",
    "    \n",
    "    ## 拿到一个状态对应的所有动作的动作价值，并返回动作价值的最大值\n",
    "    def max_q_value(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        return self.q_net(state).max().item()\n",
    "    \n",
    "    ## 使用历史数据来训练智能体的大脑，两个大脑的，一个实时update做label，另一个延迟update做predict\n",
    "    '''\n",
    "    损失函数需要label和predict，但是强化学习是没有label的，所以需要人工构造label才行，DQN使用的构造方式是使用update步长不相同的两个Qnet，\n",
    "    update数量较多的Qnet来做label，数量较少的Qnet来做predict。所以label就是使用的newest update的Qnet。相当是两个人，一个学的时间长些，\n",
    "    一个学的时间短些，所以这个学习时间更长的人，可以当老师了，学习时间短的人，就只能当学生了。老师可以教导学生的。所以两个大脑模型Qnet，\n",
    "    一个做老师，一个是学生，也就是一个label另一个则是predict。这样就构造出了相应的label。\n",
    "    target_q_net使用下一个状态，然后Q-learning来predict当前(状态，动作)的动作价值，predict\n",
    "    q_net使用当前状态和动作，直接算出当前(状态，动作)的动作价值，label\n",
    "    '''\n",
    "    def update(self, transition_dict):\n",
    "        ## 初始化 状态、动作、奖励、下一个状态、是否结束的\n",
    "        states = torch.tensor(transition_dict['states'],\n",
    "                              dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(\n",
    "            self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'],\n",
    "                                   dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'],\n",
    "                             dtype=torch.float).view(-1, 1).to(self.device)\n",
    "\n",
    "        ## target, 因该网络实时update，所以可以看作是真实值，也就是监督学习内的label，而目标网络延迟很多，目标网络的输出可以看作predict\n",
    "        ## “真实”label，q_net输入当前的状态，返回值是当前状态下每个动作的动作价值，所以gather以后拿到的是：当前(状态和动作)对应的动作价值\n",
    "        q_values = self.q_net(states).gather(1, actions)  # Q值\n",
    "        # 下个状态的最大Q值\n",
    "        if self.dqn_type == 'DoubleDQN': # DQN与Double DQN的区别\n",
    "            max_action = self.q_net(next_states).max(1)[1].view(-1, 1)    ## 统一动作网络，由q_net网络来给出下个状态的动作，标准是最大值\n",
    "            max_next_q_values = self.target_q_net(next_states).gather(1, max_action)    ## target_q_net网络给出动作价值，并通过动作选择动作价值\n",
    "        else: # DQN的情况\n",
    "            ## target_q_net网络给出动作价值，并直接挑选某个状态动作内的最大值，和q_net的动作可能不相同\n",
    "            max_next_q_values = self.target_q_net(next_states).max(1)[0].view(-1, 1)\n",
    "        ## Q-learning algorithm，算出的是当前(状态和动作)的动作价值\n",
    "        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)\n",
    "        ## q_net的truth label 和 target_q_net的predict，算损失用来反向传播\n",
    "        ## 也就是两个网络算出来的（状态和动作）对应的动作价值，用MSE来算损失函数的呢\n",
    "        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))  # 均方误差损失函数\n",
    "        self.optimizer.zero_grad()  # PyTorch中默认梯度会累积,这里需要显式将梯度置为0\n",
    "        dqn_loss.backward()   ##  反向传播求出梯度\n",
    "        self.optimizer.step() ##  使用累加的梯度来update参数\n",
    "\n",
    "        if self.count % self.target_update == 0:\n",
    "            self.target_q_net.load_state_dict(self.q_net.state_dict())  # 更新目标网络\n",
    "        self.count += 1\n",
    "\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)\n",
    "replay_buffer = rl_utils.ReplayBuffer(buffer_size) ## 实例化缓冲池也就是历史数据\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,\n",
    "            target_update, device, 'DuelingDQN')\n",
    "return_list, max_q_value_list, allimage = train_DQN(agent, env, num_episodes,\n",
    "                                          replay_buffer, minimal_size,\n",
    "                                          batch_size)\n",
    "\n",
    "# https://github.com/guicalare/Img2gif/blob/master/Code/Img2Gif.py\n",
    "imageio.mimsave(r'C:\\Users\\10696\\Desktop\\access\\Hands-on-RL\\chapter8_2.gif', allimage, duration=10)\n",
    "\n",
    "episodes_list = list(range(len(return_list)))\n",
    "mv_return = rl_utils.moving_average(return_list, 5)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('Dueling DQN on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "frames_list = list(range(len(max_q_value_list)))\n",
    "plt.plot(frames_list, max_q_value_list)\n",
    "plt.axhline(0, c='orange', ls='--')\n",
    "plt.axhline(10, c='red', ls='--')\n",
    "plt.xlabel('Frames')\n",
    "plt.ylabel('Q value')\n",
    "plt.title('Dueling DQN on {}'.format(env_name))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
